void main(List<String> arguments) {
  // test1();
  // test2();
  // test3();
  testAssert();
}

class Student {
  num a = 0;
  double b = 0;
}

/// var：如果没有初始值的时候，var可以变成任意类型。
/// dynamic：动态任意类型，编译阶段不检查类型。
/// Object：&nbsp;动态任意类型，在编译阶段检查类型。
/// 第一概念：一切皆为对象，对象的默认值是null
void test1() {

  int i = 10;
  double dd = 10.2;

  // var如果有初始值，那么类型会被锁定。
  // var a = 10;
  //var 本意上是不决定类型
  var a = 10;
  a = 10;
  // a = "dart";
  print("a:$a");

  // 这里我们使用 dynamic 声明
  // d 的数据类型可以随意改变，这种类型就是 dynamic
  dynamic d = 10;
  d++;
  d = "dart";
  print("d:" + d);
  // print("b:"+b);

  Object c = 'doucafecat';
  c = 123;
  c = [2222];
  print("c:$c");

  // JS的面向对象设计
  double b = 10;

  //高级语言的语法设计，VM---》判断---》损耗一点点性能
  //kerwin   ----->快
  double ddd = 10.2;
  int result = ddd.toInt();

  num n = 10;

  print("b:$b");

  //dart变量体系
  //1.兼容了java变量体系
  // int a1 = 10;
  double d1 = 10.2;
  print(d1);

  var v = d1;
  v++;
  print(v);

  Object obj = 10;
  // obj++;

}

///数值数据类型
void test2() {
  num a = 10; // 整形
  a = 20.1; // 浮点型
  print(a); // 20.1

  int i = 10;
  // i = 10.1;     // 这个地方会报错，因为将 int 型的数据改为 double 型 向下转型
  // i = int.parse('10.1'); // 字符串转换为int类型
  i = 10.111.round(); // 通过round()方法将double转换为int
  print(i); // 10

  double d = 20.1;
  d = 20; // 这个地方不会报错，因为将 double 型的数据改为 int 型，向上转型
  print(d); // 20.0
}

void testCase() {
  // int / double
  int i = 10;
  // i = 10.1;     // 这个地方会报错，因为将 int 型的数据改为 double 型 向下转型
  // i = int.parse('10.1'); // 字符串转换为int类型
  i = 10.1.round();// 通过round()方法将double转换为int
  i = 10.1.toInt();// 通过round()方法将double转换为int
  print(i); // 10

  double d = 20.1;
  d = 20; // 这个地方不会报错，因为将 double 型的数据改为 int 型，向上转型
  print(d); // 20.0

  int a = 20.2.toInt();

  //int / string
  int j = 10;
  String jstr = j.toString();
  int z = int.parse('66');
  // int z = int.parse('66.66'); // 报错，类型不匹配
  print(jstr); // 10
  print(z); // 66

  // int a = 10;
  // double b = 20.2;
  // int result = (a * b).toInt();


  // double / string
  double f = double.parse('9.9');
  double ff = double.parse('9');
  String fstr = 3.1415926.toStringAsFixed(6); // 保留6位小数
  String ffstr = 3.1415926.toString();
  print(f); // 9.9
  print(ff); // 9.0
  print(fstr); //3.141593
  print(ffstr); // 3.1415926
}

//check
void testAssert() {
// 检查是否为空
  var fullName = '';
  assert(fullName.isEmpty);
  print("fullname"+fullName);
// 为0检查
  var hitPoints = 0;
  assert(hitPoints <= 0);
  // print("hitPoints"+hitPoints);
// 检查是否为 null.
  var unicorn;
  assert(unicorn == null);
  //throw error
  print("unicorn${unicorn}");
// 检查是否为 NaN.
  var iMeantToDoThis = 0 / 0;
  assert(iMeantToDoThis.isNaN);
  // print("iMeantToDoThis"+iMeantToDoThis);
}

//A的引用 地址
//public static final int A = new ArrayList();
//a.add();

///常量
void test3() {
  const PI = 3.1454567;
  //使用const 定义的常量是不可变的， 需要定义并赋值，
  // 常量定义的集合，都是只读的，特性是所赋值会传递到子元素，
  // 在内存中会复用相同内容对象,const特性与ES6中的类似
  const ARY = [1, 2, 3, 4, 5];
  var ARRY = const [1, 2, 3, 5];
  //使用final 定义的变量， 只能赋值一次；并且在运行时赋值，
  // 所谓运行时，就是当程序执行到这块代码时才会对final修饰的变量进行赋值。
  // 可以是对象、字符串、数字等
  final SCORE = 123;
  //如果常量定义的是基本数据类型(int、double)，在dart中不需要定义变量的类型，
  // dart会根据赋值的情况推导类型，如果加上var就会报错
  const a = [1,2,3,4,5];
  // final a = [1, 2, 3, 4, 5];
  a[1] = 10;
  print(a[1]);
}
